/**
 * 并发数配置文件管理
 * 支持不同场景的并发数配置
 */

export interface ConcurrencyConfig {
    scenario1: {
        name: string;
        concurrency: number;
        description: string;
    };
    scenario2: {
        name: string;
        concurrency: number;
        description: string;
    };
    scenario4: {
        name: string;
        concurrency: number | string;
        description: string;
    };
    default: {
        concurrency: number;
        description: string;
    };
}

/**
 * 获取并发数配置
 * @param scenario 场景名称 ('scenario1' | 'scenario2' | 'default')
 * @returns 并发数
 */
export const getConcurrencyConfig = async (scenario: keyof ConcurrencyConfig = 'default'): Promise<number> => {
    try {
        // 动态导入配置文件
        const config = await import('./concurrency.json');
        const concurrencyConfig: ConcurrencyConfig = config.default;

        if (concurrencyConfig[scenario]) {
            const concurrency = concurrencyConfig[scenario].concurrency;
            if (typeof concurrency === 'number') {
                console.log(`📊 使用场景 ${scenario} 并发数配置: ${concurrency}`);
                return concurrency;
            } else {
                console.warn(`⚠️ 场景 ${scenario} 使用动态配置，回退到默认值`);
                return concurrencyConfig.default.concurrency;
            }
        } else {
            console.warn(`⚠️ 场景 ${scenario} 不存在，使用默认并发数`);
            return concurrencyConfig.default.concurrency;
        }
    } catch (error) {
        console.error('❌ 读取并发数配置失败:', error);
        // 回退到默认值
        return 1;
    }
};

/**
 * 获取场景2的并发数（单GPU+多图处理）
 */
export const getScenario2Concurrency = (): Promise<number> => {
    return getConcurrencyConfig('scenario2');
};

/**
 * 获取场景1的并发数（单GPU+单图处理）
 */
export const getScenario1Concurrency = (): Promise<number> => {
    return getConcurrencyConfig('scenario1');
};

/**
 * 动态获取GPU服务器数量
 * @returns GPU服务器数量
 */
export const getGPUServerCount = async (): Promise<number> => {
    try {
        // 从API网关获取GPU服务器数量
        const response = await fetch('/api/gpu-servers/count');
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        if (data.success && data.server_count !== undefined) {
            console.log(`📊 获取到GPU服务器数量: ${data.server_count}`);
            return data.server_count;
        } else {
            throw new Error('API响应格式错误');
        }
    } catch (error) {
        console.error('❌ 获取GPU服务器数量失败:', error);
        // 回退到默认值1
        return 1;
    }
};

/**
 * 获取场景4的并发数（多GPU+多图处理，动态获取）
 */
export const getScenario4Concurrency = async (): Promise<number> => {
    try {
        // 动态获取GPU服务器数量
        const serverCount = await getGPUServerCount();
        console.log(`🚀 场景4：多GPU+多图处理，并发数: ${serverCount}`);
        return serverCount;
    } catch (error) {
        console.error('❌ 获取场景4并发数失败:', error);
        // 回退到默认值1
        return 1;
    }
};
